﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;

namespace SGT_ON
{
    /// <summary>
    /// Clase utilizada para la presentación y propiedades derivadas.
    /// </summary>
    public partial class StockMovimientoStock
    {
        public string DiferenciaStock
        {
            get
            {
                int _resultado = _StockNuevo - _StockAnterior;
                if(_resultado < 0)
                    return _resultado.ToString();
                else if(_resultado > 0)
                    return "+" + _resultado.ToString();
                else
                    return _resultado.ToString();
            }
        }
        public System.Drawing.Color DiferenciaColor
        {
            get
            {
                int _resultado = _StockNuevo - _StockAnterior;
                if (_resultado <= 0)
                    return System.Drawing.Color.Red;
                else if (_resultado > 0)
                    return System.Drawing.Color.Green;
                else
                    return System.Drawing.Color.Red;
            }
        }
        public string FechaHoraString
        {
            get
            {
                return FechaHora.ToString("dd/MM/yyyy HH:mm:ss");
            }
        }
        public string ProductoEstaEnDepositoString
        {
            get
            {
                if (ProductoEstaEnDeposito == true)
                    return "Si";
                else
                    return "No";
            }
        }
    }
    /// <summary>
    /// Clase base con la lógica de negocio
    /// </summary>
    [System.ComponentModel.DataObject]
    public partial class StockMovimientoStock
    {
        #region Atributos
        protected int _id;
        protected DateTime _FechaHora;
        protected string _Observaciones;
        protected string _Responsable;
        protected int _StockAnterior;
        protected int _StockNuevo;
        protected int _IdProducto;
        protected bool _ProductoEstaEnDeposito;

        //Objetos asociados
        protected StockProducto _Producto;
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public DateTime FechaHora
        {
            get
            {
                return _FechaHora;
            }
            set
            {
                _FechaHora = value;
            }
        }
        public string Observaciones
        {
            get
            {
                return _Observaciones;
            }
            set
            {
                _Observaciones = value;
            }
        }
        public string Responsable
        {
            get
            {
                return _Responsable;
            }
            set
            {
                _Responsable = value;
            }
        }
        public int StockAnterior
        {
            get
            {
                return _StockAnterior;
            }
            set
            {
                _StockAnterior = value;
            }
        }
        public int StockNuevo
        {
            get
            {
                return _StockNuevo;
            }
            set
            {
                _StockNuevo = value;
            }
        }
        public int IdProducto
        {
            get
            {
                return _IdProducto;
            }
            set
            {
                _IdProducto = value;
            }
        }
        public bool ProductoEstaEnDeposito
        {
            get
            {
                return _ProductoEstaEnDeposito;
            }
            set
            {
                _ProductoEstaEnDeposito = value;
            }
        }
       
        //Objetos asociados
        public StockProducto Producto
        {
            get
            {
                //si lo tengo cargado, lo devuelvo
                if (_Producto != null)
                    return _Producto;

                if (IdProducto <= 0)
                    return null;

                return StockProducto.CrearStockProducto(IdProducto);
            }
            set
            {
                _Producto = value;
                IdProducto = _Producto.ID;
            }
        }

        //Propiedades derivadas
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static StockMovimientoDeStockTableAdapter _StockMovimientoStockAD;
        protected static StockMovimientoDeStockTableAdapter Adaptador
        {
            get
            {
                if (_StockMovimientoStockAD == null)
                    _StockMovimientoStockAD = new StockMovimientoDeStockTableAdapter();

                return _StockMovimientoStockAD;
            }
        }
        protected static StockMovimientoStock ObtenerPorID(int pID)
        {
            _STG_DAL.StockMovimientoDeStockDataTable _dt;

            _dt = Adaptador.ObtenerPorID(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                return AsignarRowAObjeto((_STG_DAL.StockMovimientoDeStockRow)_dt.Rows[0]);

            return null;
        }
        protected static StockMovimientoStock AsignarRowAObjeto(_STG_DAL.StockMovimientoDeStockRow pRow)
        {
            StockMovimientoStock _StockMovimientoStock = new StockMovimientoStock();
            if (pRow != null)
            {
                _StockMovimientoStock = new StockMovimientoStock();
                _StockMovimientoStock.ID = pRow.ID;
                _StockMovimientoStock.FechaHora = pRow.FechaHora;
                _StockMovimientoStock.Observaciones = pRow.Observaciones;
                _StockMovimientoStock.Responsable = pRow.Responsable;
                _StockMovimientoStock.StockAnterior = pRow.StockAnterior;
                _StockMovimientoStock.StockNuevo = pRow.StockNuevo;
                _StockMovimientoStock.IdProducto = pRow.IdProducto;
                _StockMovimientoStock.ProductoEstaEnDeposito = pRow.ProductoEstaEnDeposito;
            }
            return _StockMovimientoStock;
        }
        protected static int Insertar(DateTime pFechaHora,string pObservaciones,string pResponsable,int pStockAnterior,int pStockNuevo,int pIdProducto, bool pProductoEstaEnDeposito)
        {
            return int.Parse(Adaptador.Insertar(pFechaHora, pObservaciones, pResponsable, pStockAnterior, pStockNuevo, pIdProducto, pProductoEstaEnDeposito).ToString());
        }
        public bool Actualizar(DateTime pFechaHora, string pObservaciones, string pResponsable, int pStockAnterior, int pStockNuevo, int pIdProducto,bool pProductoEstaEnDeposito, int pId)
        {

            if (0 < Adaptador.Actualizar(pFechaHora, pObservaciones, pResponsable, pStockAnterior, pStockNuevo, pIdProducto, pProductoEstaEnDeposito, pId))
                return true;
            else
                return false;
        }
        public bool Actualizar()
        {
            return Actualizar(FechaHora, Observaciones, Responsable, StockAnterior, StockNuevo, IdProducto, ProductoEstaEnDeposito, ID);
        }
        //public void Eliminar()
        //{
        //    StockMovimientoStock _StockMovimientoStock = StockMovimientoStock.ObtenerPorID(this.ID);
        //    _StockMovimientoStock.EstaActivo = false;
        //    _StockMovimientoStock.Actualizar();
        //}
        protected static StockMovimientoStockColeccion AsignarStockMovimientoStockTableAdapterAStockMovimientoStockColeccion(_STG_DAL.StockMovimientoDeStockDataTable pDataTable)
        {
            StockMovimientoStockColeccion _StockMovimientoStockes = new StockMovimientoStockColeccion();
            StockMovimientoStock _StockMovimientoStock;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.StockMovimientoDeStockRow _row in pDataTable.Rows)
                {
                    _StockMovimientoStock = AsignarRowAObjeto(_row);
                    if (_StockMovimientoStock != null)
                        _StockMovimientoStockes.Add(_StockMovimientoStock);
                }
            }
            return _StockMovimientoStockes;
        }
        //public static StockMovimientoStockColeccion ObtenerTodosLosStockMovimientoStocks()
        //{
        //    return AsignarStockMovimientoStockTableAdapterAStockMovimientoStockColeccion(Adaptador.ObtenerTodos());
        //}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="pTexto"></param>
        /// <returns></returns>
        public static StockMovimientoStockColeccion ObtenerPorTexto(int pIdProducto)
        {
            return AsignarStockMovimientoStockTableAdapterAStockMovimientoStockColeccion(Adaptador.ObtenerMovimientosDeProducto(pIdProducto));
        }
        /// <summary>
        /// Obtiene los productos que estan en deposito y no han sido entregados cuando el presupuesto se cancela o se ha cobrado
        /// Estos elementos son para que no haya productos asignados a reparaciones y no se hayan usado.
        /// </summary>
        /// <returns></returns>
        public static StockMovimientoStockColeccion ObtenerElementosEnDeposito()
        {
            return AsignarStockMovimientoStockTableAdapterAStockMovimientoStockColeccion(Adaptador.ObtenerElementosEnDeposito());
        }
        #endregion

        #region Métodos
        public StockMovimientoStock()
        {
            AsignarValoresIniciales();
        }

        public void AsignarValoresIniciales()
        {
            _id = -1;
            FechaHora = Parametros.FechaMinima;
            Observaciones = "";
            Responsable = "";
            StockAnterior = 0;
            StockNuevo = 0;
            IdProducto = -1;
            ProductoEstaEnDeposito = true;
        }

        public static StockMovimientoStock CrearStockMovimientoStock()
        {
            StockMovimientoStock _StockMovimientoStock = new StockMovimientoStock();
            return _StockMovimientoStock;
        }
        public static StockMovimientoStock CrearStockMovimientoStock(int pID)
        {
            StockMovimientoStock _StockMovimientoStock = ObtenerPorID(pID);
            return _StockMovimientoStock;
        }
        //public void Actualizar()
        //{
        //     Actualizar((CantidadReposicion, CodigoOriginal, CodigoTaller, Descripcion, EsComercializable, EsNuevo, EstaActivo, FotoURL, IVA, Nombre, PrecioCosto, PrecioVenta, TieneNumeroDeSerie, TipoDeMovimientoStock, Ubicacion, UnidadDeMedida, Marca, Cantidad, ID);
        //}
        public int Insertar()
        {
            return Insertar(FechaHora, Observaciones, Responsable, StockAnterior,StockNuevo, IdProducto, ProductoEstaEnDeposito);
        }
        /// <summary>
        /// Genera un movimiento de stock con los parametros especificados.
        /// </summary>
        /// <param name="pObservaciones"></param>
        /// <param name="pResponsable"></param>
        /// <param name="pStockNuevo"></param>
        /// <param name="pIdProducto"></param>
        public static int GenerarMovimientoDeStock(string pObservaciones,string pResponsable,int pStockNuevo,int pIdProducto)
        {
            StockProducto _producto = StockProducto.CrearStockProducto(pIdProducto);

            int _StockAnterior = _producto.Cantidad;
            if (pObservaciones == "Alta de producto") // verifico si se esta creando el producto para poner el stock anterior en 0
                _StockAnterior = 0;

            StockProducto.Actualizar(_producto.CantidadReposicion, _producto.CodigoOriginal, _producto.Descripcion, _producto.EsComercializable, _producto.EsNuevo, _producto.EstaActivo, _producto.FotoURL, _producto.IVA, _producto.Nombre, _producto.PrecioCosto, _producto.PrecioVenta, _producto.TieneNumeroDeSerie, _producto.TipoDeProducto, _producto.Ubicacion, _producto.UnidadDeMedida, _producto.Marca, pStockNuevo, _producto.ID);
            
            return Insertar(DateTime.Now, pObservaciones, pResponsable, _StockAnterior, pStockNuevo, pIdProducto, true);
        }
        /// <summary>
        /// Genera un movimiento de stock con los parametros especificados
        /// Actualiza la cantidad de stock en el producto.
        /// </summary>
        /// <param name="pObservaciones"></param>
        /// <param name="pResponsable"></param>
        /// <param name="pDiferenciaStock">Es la cantidad que se suma o resta segun el signo al stock actual</param>
        /// <param name="pIdProducto"></param>
        public static int GenerarMovimientoDeStockConDiferencia(string pObservaciones, string pResponsable, int pDiferenciaStock, int pIdProducto, bool pProductoEstaEnDeposito)
        {
            StockProducto _producto = StockProducto.CrearStockProducto(pIdProducto);

            int _StockAnterior = _producto.Cantidad;
            int _StockNuevo = _producto.Cantidad + pDiferenciaStock;
            if (pObservaciones == "Alta de producto") // verifico si se esta creando el producto para poner el stock anterior en 0
                _StockAnterior = 0;

            StockProducto.Actualizar(_producto.CantidadReposicion, _producto.CodigoOriginal, _producto.Descripcion, _producto.EsComercializable, _producto.EsNuevo, _producto.EstaActivo, _producto.FotoURL, _producto.IVA, _producto.Nombre, _producto.PrecioCosto, _producto.PrecioVenta, _producto.TieneNumeroDeSerie, _producto.TipoDeProducto, _producto.Ubicacion, _producto.UnidadDeMedida, _producto.Marca, _StockNuevo, _producto.ID);

            return Insertar(DateTime.Now, pObservaciones, pResponsable, _StockAnterior, _StockNuevo, pIdProducto, pProductoEstaEnDeposito);
        }
        #endregion

        #region Metodos para datasource

        //public void Actualizar(StockMovimientoStock pStockMovimientoStock)
        //{
        //    if (pStockMovimientoStock != null)
        //        pStockMovimientoStock.Actualizar();
        //}
        public int Insertar(StockMovimientoStock pStockMovimientoStock)
        {
            if (pStockMovimientoStock != null)
                return pStockMovimientoStock.Insertar();
            return -1;
        }
        //public void Eliminar(StockMovimientoStock pStockMovimientoStock)
        //{
        //    pStockMovimientoStock.Eliminar();
        //}
        #endregion
    }
    [System.ComponentModel.DataObject]
    public class StockMovimientoStockColeccion : System.Collections.CollectionBase
    {
        public void Add(StockMovimientoStock pStockMovimientoStock)
        {
            this.List.Add(pStockMovimientoStock);
        }
        public void AddUnico(StockMovimientoStock pStockMovimientoStock)
        {
            foreach (StockMovimientoStock _StockMovimientoStock in this)
                if (pStockMovimientoStock.ID == _StockMovimientoStock.ID)
                    return;
            this.List.Add(pStockMovimientoStock);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(StockMovimientoStock pStockMovimientoStock)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pStockMovimientoStock.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public StockMovimientoStock this[int index]
        {
            get { return ((StockMovimientoStock)(this.List[index])); }
            set { this.List[index] = value; }
        }

        #region Metodos de colección

        #endregion
        #region Para datasource
        public void Insertar(StockMovimientoStock pStockMovimientoStock)
        {
            pStockMovimientoStock.Insertar(pStockMovimientoStock);
        }
        #endregion
    }
}

